home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1999 March - Disc 1 / Macworld (1999-03) (Disk 1).dmg / Shareware World / Utilities / Text Processing / Alpha / Tcl / Modes / shellMode.tcl < prev    next >
Encoding:
Text File  |  1998-12-15  |  16.3 KB  |  651 lines  |  [TEXT/ALFA]
  1. ## -*-Tcl-*-
  2.  # ###################################################################
  3.  # 
  4.  #  FILE: "shellMode.tcl"
  5.  #                                last update: 15/12/1998 {9:53:46 pm} 
  6.  #  Author: Vince Darley, Pete Keleher
  7.  #  E-mail: <darley@fas.harvard.edu>
  8.  #    mail: Division of Engineering and Applied Sciences, Harvard University
  9.  #          Oxford Street, Cambridge MA 02138, USA
  10.  #     www: <http://www.fas.harvard.edu/~darley/>
  11.  #  
  12.  # Some Copyright (c) 1997-1998  Vince Darley, all rights reserved
  13.  # Some copyright Pete Keleher.
  14.  # 
  15.  #  Description: 
  16.  # 
  17.  # General purpose shell routines for Alpha.  Two and a half shells
  18.  # are provided by default: the Alpha Tcl shell, the MPW toolserver
  19.  # shell and half of the comet shell (whatever that is).
  20.  # 
  21.  # A separate package 'remotetclshell' allows Alpha to act as a console
  22.  # for a separately running Wish.
  23.  # ###################################################################
  24.  ##
  25.  
  26. alpha::mode Shel 1.7.5 dummyShel [list {"*tcl sh*"}] tclMenu {
  27.     regModeKeywords -m {«} Shel {}
  28.     addMode MPW {} [list "*Toolserver shell*"] {}
  29.     # we use our own version since Alpha doesn't quite change mode
  30.     # to Shel correctly (not sure what it does wrong).
  31.     catch {rename shell {}}
  32.     # we do this ourselves.  this way we don't need a special hack
  33.     # in 'openHook'
  34.     catch {rename toolserverShell {}}
  35. }
  36.  
  37. newPref v wordBreak {(\$)?[a-zA-Z0-9_.]+} Shel
  38. newPref f wordWrap {0} Shel
  39. newPref f perlCallUnixLike {0} Shel
  40. newPref v wordBreakPreface {[^a-zA-Z0-9_\$]} Shel
  41. newPref f autoMark 0 Shel
  42. newPref f tcl_interactive 1 Shel
  43. set invisibleModeVars(tcl_interactive) 1
  44. set Shel::endPara {^«.*$}
  45. set Shel::startPara {^«.*$}
  46. ensureset Shel::histnum 0
  47.  
  48. Bind '\r' Shel::carriageReturn "Shel"
  49. Bind '\r' Shel::carriageReturn "MPW"
  50. Bind '\t' bind::Completion Shel
  51.  
  52. Bind up <z> Shel::prevHist Shel
  53. Bind down <z> Shel::nextHist Shel
  54.  
  55. Bind 'a' <z> Shel::Bol Shel
  56. Bind up Shel::up Shel
  57. Bind down Shel::down Shel
  58.  
  59. Bind 'u' <z> Shel::killLine Shel
  60.  
  61. proc dummyShel {} {}
  62.  
  63. ensureset otherDirs {}
  64.  
  65. proc Shel::OptionTitlebar {} {
  66.     regsub -all "\n *" [history] "\} \{" h
  67.     set h "\{[string trim $h]\}"
  68. }
  69.  
  70. proc Shel::OptionTitlebarSelect {item} {
  71.     insertText [string range $item [expr 2+[string first " " $item]] end]
  72.     Shel::carriageReturn
  73. }
  74.  
  75. proc Shel::DblClick {args} { eval Tcl::DblClick $args }
  76.  
  77. ## 
  78.  # -------------------------------------------------------------------------
  79.  # 
  80.  # "Shel::carriageReturn" --
  81.  # 
  82.  #  Rewritten to avoid need for global _text _return variables
  83.  # -------------------------------------------------------------------------
  84.  ##
  85. proc Shel::carriageReturn {} {
  86.     global mode histnum Shel::Type
  87.     set pos [getPos]
  88.  
  89.     if {![catch {regexp {∞} [getText $pos [nextLineStart $pos]]} res] && $res} {
  90.     gotoMatch; return;
  91.     }
  92.     set ind [string first "»" [getText [lineStart $pos] $pos]]
  93.     if {$ind < 0} {
  94.     insertText "\r"
  95.     return
  96.     }
  97.     endOfLine
  98.     set fileName [win::CurrentTail]
  99.     set type [set Shel::Type($fileName)]
  100.     # sort out where we're going to put the answer
  101.     set t [getText [pos::math [lineStart $pos] + [expr $ind+2]] [getPos]]
  102.  
  103.     if {[pos::compare [getPos] != [maxPos]]} {
  104.     goto [set pos [maxPos]]
  105.     set ind [string first "»" [getText [lineStart $pos] $pos]]
  106.     if {$ind < 0} {
  107.         insertText "\r" [${type}::Prompt]
  108.     } else {
  109.         set ind [pos::math [lineStart $pos] + [expr $ind +2]]
  110.         if {$ind != $pos} {
  111.         deleteText $ind $pos
  112.         }
  113.     }
  114.     insertText -w $fileName $t
  115.     }
  116.     # carry out the action
  117.     insertText -w $fileName "\r"
  118.     set r [${type}::evaluate $t]
  119.     insertText -w $fileName $r 
  120.     if {$r != ""} { 
  121.     insertText -w $fileName "\r"
  122.     }
  123.     insertText -w $fileName [${type}::Prompt]
  124. }
  125.  
  126. proc Shel::start {type {title ""} {startuptext ""}} {
  127.     if {$title != ""} {
  128.     if {[lsearch -exact [winNames] $title] != -1} {
  129.         bringToFront $title
  130.         return
  131.     }
  132.     new -n $title -m Shel
  133.     setWinInfo shell 1
  134.     if {$startuptext != ""} {
  135.         insertText $startuptext
  136.     }
  137.     }
  138.     global Shel::Type
  139.     set c [win::Current]
  140.     set Shel::Type($c) $type
  141.     insertText -w $c [${type}::Prompt]
  142. }
  143.  
  144. # ◊◊◊◊ Alpha shell routines ◊◊◊◊ #
  145.  
  146. proc tclLog {args} {
  147.     catch {eval insertText -w [list "*tcl shell*"] $args}
  148. }
  149.  
  150. proc shell {} {
  151.     Shel::start "Alpha" "*tcl shell*" "Welcome to Alpha's Tcl shell.\r"
  152. }
  153.  
  154. namespace eval Alpha {}
  155.  
  156. proc Alpha::evaluate {t} {
  157.     global errorInfo Shel::histnum
  158.     global Shel::AlphaAlias
  159.     history add $t
  160.     set msg {}
  161.     set lt [expandAliases $t Tcl]
  162.     switch -regexp -- $lt {
  163.       {^\s*alias\s+.*} {
  164.         message "alias to be added"
  165.         if {[llength $lt] != 3} {
  166.             set msg "Error: wrong number of arguments.\rForm is: alias <abrev> <replacement>"
  167.         } else {
  168.             catch {Shel::alias [lindex $lt 1] [lrange $lt 2 2]} msg
  169.         } 
  170.         
  171.       }
  172.       default {
  173.         if {[set code [catch {uplevel \#0 $lt} msg]] == 1} {
  174.             # strip off end of error due to 'uplevel' command
  175.             set new [split $errorInfo \n]
  176.             set new [join [lrange $new 0 [expr [llength $new] - 4]] \n]
  177.             set errorInfo "$new"
  178.             set msg "Error: $msg"
  179.         }
  180.       }
  181.     }
  182.     set Shel::histnum [history nextid]
  183.     return $msg
  184.     
  185. }
  186. proc Alpha::Prompt {} {
  187.     return "«[file tail [string trimright [pwd] {:}]]» "
  188. }
  189.  
  190. # ◊◊◊◊ MPW routines ◊◊◊◊ #
  191. namespace eval mpw {}
  192. proc mpw::evaluate {t} {
  193.     catch {dosc -n ToolServer -s $t} r
  194.     return $r
  195. }
  196. proc mpw::Prompt {} { return "«mpw» " }
  197. proc toolserverShell {} {
  198.     Shel::start "mpw" {*Toolserver shell*} \
  199.       "Welcome to Alpha's MPW shell (using ToolServer via AppleEvents).\r"
  200.     if [catch {app::ensureRunning ToolServer MPSX}] {
  201.         killWindow
  202.     }
  203. }
  204.  
  205. # ◊◊◊◊ Comet routines ◊◊◊◊ #
  206. namespace eval comet {}
  207. proc comet::evaluate {t} {
  208.     cometSendAndPrompt $t
  209.     return ""
  210. }
  211. proc comet::Prompt {} {}
  212.  
  213. # ◊◊◊◊ General purpose ◊◊◊◊ #
  214.  
  215. proc expandAliases {cmdLine {shellType Tcl}} {
  216.     global Shel::AlphaAlias
  217.     if {![info exists Shel::AlphaAlias]} {
  218.         return $cmdLine 
  219.     } 
  220.     while {[string length $cmdLine]} {
  221.         if {[regexp -indices -- \
  222.           {([$]\{?|set\s+)?\b([a-zA-Z_][a-zA-Z_0-9]*)\b(([\.]|(::))[a-zA-Z_0-9]*)*} \
  223.           $cmdLine all dc poss]} {
  224.             if {$all != $poss} {
  225.                 set end [lindex $all 1]
  226.                 append rtnVal [string range $cmdLine 0 $end]
  227.                 set cmdLine [string range $cmdLine [incr end] end]
  228.             } else {
  229.                 set start [lindex $poss 0]
  230.                 set end [lindex $poss 1]
  231.                 if {$start != 0} {
  232.                     append rtnVal [string range $cmdLine 0 [expr $start - 1]]                
  233.                 } 
  234.                 set possAlias [string range $cmdLine $start $end]
  235.                 if {[info exists Shel::AlphaAlias($possAlias)]} {
  236.                     append rtnVal [set Shel::AlphaAlias($possAlias)] 
  237.                 } else {
  238.                     append rtnVal [string range $cmdLine $start $end]
  239.                 } 
  240.                 set cmdLine [string range $cmdLine [incr end] end]
  241.             } 
  242.         } else {
  243.             append rtnVal $cmdLine
  244.             break
  245.         }
  246.     }
  247.     return $rtnVal
  248. }
  249.  
  250. proc Shel::alias {abrev replacement} {
  251.     global Shel::Type
  252.     set fileName [win::CurrentTail]
  253.     set type [set Shel::Type($fileName)]
  254.     
  255.     if {![regexp -- $abrev {[a-zA-Z_][a-zA-Z_0-9]*}]} {
  256.     return "The name used for an alias must start with an alphabetic character \
  257.       \nor an underscore, followed by zero or more characters of the same sort \
  258.       \n(with numbers allowed also)."
  259.     }
  260.     
  261.     if {"[info commands $abrev][procs::find $abrev]" != ""} {
  262.     beep
  263.     if {![string match [askyesno -c "'$abrev' is already a Tcl command, do you wish to Cancel?"] no ] } {
  264.         return "No alias was formed"
  265.     }        
  266.     } 
  267.     
  268.     global Shel::${type}Alias
  269.     if {[info exists Shel::${type}Alias($abrev)]} {
  270.     beep
  271.     if {![string match [askyesno -c "'$abrev' is already an alias for this shell, do you wish to Cancel?" ] no ] } {
  272.         return "No alias was formed"
  273.     } 
  274.     } 
  275.     mode::addUserLine [list set Shel::${type}Alias($abrev) $replacement]
  276.     return "Saved alias in ShellPref.tcl file"
  277. }
  278.  
  279. proc Shel::prevHist {} {
  280.     global Shel::histnum Shel::curCmdLine
  281.     
  282.     set text [getText [lineStart [getPos]] [nextLineStart [getPos]]]
  283.     if {[set ind [string first "» " $text]] > 0} {
  284.         goto [pos::math [lineStart [getPos]] + $ind + 2]
  285.     } else return
  286.  
  287.     incr Shel::histnum -1
  288.     if {[catch {history event ${Shel::histnum}} text]} {
  289.         incr Shel::histnum
  290.         endOfLine
  291.         beep
  292.         return
  293.     }
  294.     set to [nextLineStart [getPos]]
  295.     if {[lookAt [pos::math $to -1]] == "\r"} {set to [pos::math $to -1]}
  296.     if { [expr ${Shel::histnum} + 1] == [history nextid] } {
  297.         set Shel::curCmdLine [getText [getPos] $to]
  298.     }
  299.     replaceText [getPos] $to $text
  300. }
  301.  
  302.  
  303. proc Shel::nextHist {} {
  304.     global Shel::histnum Shel::curCmdLine
  305.   
  306.     set text [getText [lineStart [getPos]] [nextLineStart [getPos]]]
  307.     if {[set ind [string first "» " $text]] > 0} {
  308.         goto [pos::math [lineStart [getPos]] + $ind + 2]
  309.     } else return
  310.  
  311.     if {${Shel::histnum} == [history nextid]} {
  312.         beep
  313.         endOfLine
  314.         return
  315.     }
  316.     
  317.     incr Shel::histnum
  318.     if {${Shel::histnum} == [history nextid]} {
  319.         set text ${Shel::curCmdLine}
  320.     } else {
  321.         if {[catch {history event ${Shel::histnum}} text]} {
  322.             endOfLine
  323.             return
  324.         }
  325.     }
  326.     set to [nextLineStart [getPos]]
  327.     if {[lookAt [pos::math $to - 1]] == "\r"} {set to [pos::math $to -1]}
  328.     replaceText [getPos] $to $text
  329. }
  330.  
  331. proc Shel::killLine {} {
  332.     set text [getText [lineStart [getPos]] [nextLineStart [getPos]]]
  333.     if {[set ind [string first "» " $text]] > 0} {
  334.         goto [pos::math [lineStart [getPos]] + [expr $ind + 2]]
  335.     } else {
  336.         return
  337.     }
  338.     set to [nextLineStart [getPos]]
  339.     if {[lookAt [pos::math $to - 1]] == "\r"} {set to [pos::math $to - 1]}
  340.     deleteText [getPos] $to
  341. }
  342.  
  343. proc Shel::Bol {} {
  344.     set text [getText [lineStart [getPos]] [nextLineStart [getPos]]]
  345.     if {[set ind [string first "» " $text]] > 0} {
  346.         goto [pos::math [lineStart [getPos]] + [expr $ind + 2]]
  347.     } else {
  348.         goto [lineStart [getPos]]
  349.     }
  350. }
  351.  
  352. proc Shel::up {} {
  353.     set pos [pos::math [lineStart [getPos]] - 1]
  354.     if {[catch {regexp {∞} [getText [lineStart $pos] [nextLineStart $pos]]} res] || !$res} {
  355.         previousLine; return
  356.     }
  357.     select [lineStart $pos] [nextLineStart $pos]
  358. }
  359.  
  360. proc Shel::down {} {
  361.     set pos [nextLineStart [getPos]]
  362.     if {[catch {regexp {∞} [getText $pos [nextLineStart $pos]]} res] || !$res} {
  363.         nextLine; return
  364.     }
  365.     select $pos [nextLineStart $pos]
  366. }
  367.  
  368. # ◊◊◊◊ Unix imitation ◊◊◊◊ #
  369.  
  370. proc l {args} {
  371.     eval [concat "ls -CF" $args]}
  372.  
  373. proc ll {args} {
  374.     eval [concat "ls -l" $args]}
  375.  
  376.  
  377. proc wc {args} {
  378.     set res {}
  379.     set totChars 0
  380.     set totLines 0
  381.     set totWords 0
  382.     set args [glob -nocomplain $args]
  383.     foreach file $args {
  384.         set id [open $file]
  385.         set chars [string length [set text [read $id]]]
  386.         set lines [llength [split $text "\n"]]
  387.         set words [llength [split $text]]
  388.         append res [format "\r%8d%8d%8d    $file" $lines $words $chars]
  389.         set totChars [expr $totChars+$chars]
  390.         set totWords [expr $totWords+$words]
  391.         set totLines [expr $totLines+$lines]
  392.         close $id
  393.     }
  394.     if {[llength $args] > 1} {
  395.         append res [format "\r%8d%8d%8d    total" $totLines $totWords $totChars]
  396.     }
  397.     return [string range $res 1 end]
  398. }
  399.  
  400.  
  401.  
  402. #================================================================================
  403. # To prevent ambiguity, 'from' is assumed to be a complete pathname, ending
  404. # in a directory name. If it doesn't end w/ a colon, one is added. 'to' is
  405. # assumed to be the parent directory of the top directory we are creating.
  406. #================================================================================
  407. proc cpdir {from to} {
  408.     set cwd [pwd]
  409.     if {[string match ":*" $from] || [string match ":*" $to] ||
  410.         ![file exists $from] || ![file exists $to]} {
  411.         error "'cpdir' args must be complete pathnames of existing folders."
  412.     }
  413.     if {![string match "*:" $from]} {append from ":"}
  414.     if {![string match "*:" $to]} {append to ":"}
  415.     
  416.     if {![file isdir $from] || ![file isdir $to]} {
  417.         exit 1
  418.     }
  419.         
  420.     set res [catch {cphier $from $to} val]
  421.     cd $cwd
  422.     if {$res} {error $val}
  423. }
  424.  
  425. proc cphier {from to} {
  426.     set savedir [pwd]
  427.     if {[string index $from [expr [string len $from] - 1]] != ":"} {append from ":"}
  428.     set dir [file tail [string trimright $from ":"]]
  429.     cd $to
  430.     mkdir "$dir"
  431.     foreach f [glob "$from*"] {
  432.         if {[file isdir $f]} {
  433.             cphier "$f:" "$to$dir:"
  434.         } else {
  435.             cp $f $to$dir:
  436.         }
  437.     }
  438.     cd $savedir
  439. }
  440.  
  441.         
  442. #================================================================================
  443. #####
  444. # (Usage:  'lt' sorts by time, like UNIX's 'ls -lt'.
  445. #          'lt -t' sorts by filename, like UNIX's 'ls -l'.
  446. #          Optionally a directory name can be added as an argument.)
  447.  
  448. proc sortdt {dt} {
  449.     scan $dt "%d/%d/%d {%d:%d:%d %1sM}" mon day yea hou min sec z
  450.     if {$z == "P"} {incr hou 12}
  451.     if {[string length $yea] == 1} {
  452.         set year 200$yea
  453.     } elseif {$yea > 40} {
  454.         set year 19$yea
  455.     } else {
  456.         set year 20$yea
  457.     }
  458.     return [format "%04d%02d%02d%02d%02d" $year $mon $day $hou $min]
  459. }
  460.  
  461.  
  462. proc lth args {
  463.     global mode
  464.     
  465.     set val "*"
  466.     set sort 1
  467.     scan [lindex [mtime [now]] 0] "%d/%d/%d" one two three
  468.     if {[string length $three] == 1} {
  469.         set year 200$three
  470.     } elseif {$three > 40} {
  471.         set year 19$three
  472.     } else {
  473.         set year 20$three
  474.     }
  475.     
  476.     foreach arg $args {
  477.         switch -- $arg {
  478.             "-t"    {set sort 0}
  479.             default {set val $arg}
  480.         }
  481.     }
  482.     set mod ""
  483.     foreach f [eval glob $val] {
  484.         if {[catch {getFileInfo $f info}]} {
  485.             if {$sort} {set mod "000000000000 "}
  486.             lappend text [format "%s%s %8d%8d %6s %5s %4s %s %s\n" $mod "D" "0" "0" "" "" "" "DIR " [file tail $f]]
  487.             continue
  488.         }
  489.         if {$sort} {set mod "[sortdt [mtime $info(modified) s]] "}
  490.         set m [mtime $info(modified) a]
  491.         set zer [lindex $m 0]
  492.         set dat [format "%s %2s" [lindex $zer 1] [string trimright [lindex $zer 2] {,}]]
  493.         if {[lindex $zer 3] == $year} {
  494.             if {[scan [lindex $m 1] "%d:%d:%d %s" one two three am] != 4} {
  495.                 error "Didn't get four from scan"
  496.             }
  497.             if {[string length $two] == 1} {set two "0$two"}
  498.             set tm [expr {$am == "AM"} ? $one : [expr $one + 12]]:$two
  499.         } else {
  500.             set tm " [lindex $zer 3]"
  501.         }
  502.         lappend text [format "%sF %8d%8d %s %5s %s %s %s\n" $mod $info(datalen) $info(resourcelen) $dat $tm $info(type) $info(creator) [file tail $f]]
  503.     }
  504.     if {$sort} {
  505.         foreach ln [lsort -de $text] {
  506.             append txt [string range $ln 13 end]
  507.         }
  508.         set ans [string trimright $txt]
  509.     } else {
  510.         set ans [string trimright [join $text {}]]
  511.     }
  512.     
  513.     if { $mode=="Shel" } { return $ans } else {
  514.         new
  515.         insertText $ans "\r"
  516.         catch shrinkHeight
  517.         setWinInfo dirty 0
  518.         setWinInfo read-only 1
  519.     }
  520. }
  521.  
  522. #================================================================================
  523. proc ps {} {
  524.     foreach p [processes] {
  525.         append text [format "%-25s %4s %10d %10d\r" [lindex $p 0] [lindex $p 1] [lindex $p 2] [lindex $p 3]]
  526.     }
  527.     return [string trimright $text]
  528. }
  529.  
  530.  
  531. #================================================================================
  532. # Recursively make creator of all text files 'ALFA'. Optionally takes a starting
  533. # dir argument, otherwise starts in current directory. Auto-Doubled are no 
  534. # longer recognized by auto-doubler! Why? Some sort of conflict w/ 'PBSetFInfo'.
  535. proc creator {{dir ":"}}  {
  536.     if {![catch {glob -t TEXT $dir*} files]} {
  537.         foreach f $files {
  538.             message $f
  539.             setFileInfo $f creator ALFA
  540.         }
  541.     }
  542.     
  543.     if {![catch {glob $dir*} dirs]} {
  544.         foreach d $dirs {
  545.             if {[file isdir $d]} {creator $d:}
  546.         }
  547.     }
  548. }
  549.  
  550.  
  551. #===============================================================================
  552.  
  553. proc tomac args {
  554.     set files {}
  555.     foreach arg $args {
  556.         append files " " [glob $arg]
  557.     }
  558.     set dir [pwd]
  559.     
  560.     foreach f $files {
  561.         message "$f..."
  562.         set fd [open $dir$f "r"]
  563.         set text [read $fd]
  564.         close $fd
  565.         regsub -all "\n" $text "\r" text
  566.         
  567.         set fd [open "$dir$f" "w"]
  568.         puts -nonewline $fd $text
  569.         close $fd
  570.     }
  571.     message ""
  572. }
  573.  
  574.  
  575. #===============================================================================
  576.  
  577. proc unixToMac {fname} {
  578.     set fd [open $fname]
  579.     set text [read $fd]
  580.     close $fd
  581.     set fd [open $fname "w"]
  582.     puts -nonewline $fd $text
  583.     close $fd
  584. }
  585.  
  586. proc setCreator args {
  587.     set files {}
  588.     set creator [car $args]
  589.     foreach arg [cdr $args] {
  590.         append files " " [glob $arg]
  591.     }
  592.     
  593.     foreach f $files {
  594.         setFileInfo $f creator $creator
  595.     }
  596. }
  597.  
  598. proc setType args {
  599.     set files {}
  600.     set type [car $args]
  601.     foreach arg [cdr $args] {
  602.         append files " " [glob $arg]
  603.     }
  604.     
  605.     foreach f $files {
  606.         setFileInfo $f type $type
  607.     }
  608. }
  609. #===============================================================================
  610.  
  611. proc pushd {args} {
  612.     global otherDirs
  613.     if {[string length $args]} {
  614.         set otherDirs [cons [pwd] $otherDirs]
  615.         cd [string trim [eval list $args] "        \{\}"]
  616.     } else {
  617.         if {[llength $otherDirs]} {
  618.             set n [car $otherDirs]
  619.             set otherDirs [cons [pwd] [cdr $otherDirs]]
  620.             cd $n
  621.         } else {
  622.             return "No other directories"
  623.         }
  624.     }
  625. }
  626. proc pd {args} {
  627.     if {[string length $args]} {
  628.         eval pushd $args
  629.     } else {
  630.         pushd
  631.     }
  632. }
  633.  
  634.  
  635. proc dirs {} {global otherDirs; cons [pwd] $otherDirs}
  636.  
  637. proc popd {} {
  638.     global otherDirs
  639.     if {[llength $otherDirs]} {
  640.         cd [car $otherDirs]
  641.         set otherDirs [cdr $otherDirs]
  642.     } else {
  643.         return "No other directories"
  644.     }
  645. }
  646.  
  647.  
  648.  
  649.  
  650.  
  651.